package com.jt.service;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.jt.mapper.ItemCatMapper;
import com.jt.mapper.UserMapper;
import com.jt.pojo.ItemCat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Service
public class ItemCatServiceImpl implements ItemCatService {
    @Autowired
    private ItemCatMapper itemCatMapper;

    @Override
    public List<ItemCat> findItemCatList(Integer level){
       return itemCatMapper.findItemCatList(level);
       // 普通mybatis实现商品三级分类，总耗时60ms左右
    }
    @Override
    public void updateStatusById(ItemCat itemCat) {
        itemCatMapper.updateStatusById(itemCat);
    }

    @Override
    public int saveItemCat(ItemCat itemCat) {
        Date date = new Date();
        itemCat.setCreated(date);
        itemCat.setUpdated(date);
        itemCat.setStatus(true);
        return itemCatMapper.saveItemCat(itemCat);

    }

    /**
     * 优化手段:
     *      思路:获取所有的数据库记录,之后按照父子级关系进行封装
     *      数据结构: Map<k,v>
     *               Map<parentId,List当前父级的子级信息(不嵌套)>
     *      例子:     Map<0,List[{id=1,name="xx",children=null}.....]>
     *
     * 封装数据规则:
     *      1.遍历所有的数据.
     *      2.获取parentId
     *      3.判断parentId是否存在,之后实现数据封装
     */
    public Map<Integer, List<ItemCat>> getMap() {
        Map<Integer, List<ItemCat>> map = new HashMap<>();
        //查询所有的数据库记录
        List<ItemCat> list = itemCatMapper.selectList(null);
        //1.遍历数据
        for (ItemCat itemCat : list) {
            //获取parentId
            int parentId = itemCat.getParentId();
            if (map.containsKey(parentId)) {  //判断集合中是否有key
                //表示数据存在,将自己追加
                map.get(parentId).add(itemCat);
            } else {
                //key不存在, 定义list集合,将自己作为第一个元素追加
                List<ItemCat> childrenList = new ArrayList<>();
                childrenList.add(itemCat);
                //将数据保存到map集合中
                map.put(parentId, childrenList);
            }
        }
        return map;
    }


    @Override
    public List<ItemCat> findItemCatListMP(Integer level) {
        //获取所有集合数据
        Map<Integer, List<ItemCat>> map = getMap();
        //一级商品分类信息  1
        if (level==1){
            return map.get(0);
            //二级商品分类信息  1-2
        }else if(level ==2){
            return getTwoList(map);
            //三级商品分类信息  1-2-3
        }else if(level==3){
            return getThreeList(map);
            // map集合优化商品三级分类，总耗时为15ms左右
        }
        return null;
    }
    public List<ItemCat> getTwoList(Map<Integer,List<ItemCat>> map){
        List<ItemCat> onelist=map.get(0);
        for (ItemCat oneItemCat:onelist) {
                int parentId = oneItemCat.getId();
                List<ItemCat> twolist = map.get(parentId);
                    oneItemCat.setChildren(twolist);
        }
        return onelist;
    }

    public List<ItemCat> getThreeList(Map<Integer,List<ItemCat>> map){
        List<ItemCat> twolist=getTwoList(map);
        for (ItemCat twoItemCat:twolist) {
                List<ItemCat> twoList = twoItemCat.getChildren();
                if (twoList ==null || twoList.size()==0)continue;
            for (ItemCat twoItemcat:twoList) {
                int parentId=twoItemcat.getId();
                List<ItemCat> threelist=map.get(parentId);
                    twoItemcat.setChildren(threelist);
            }
        }
        return twolist;
    }
    //优化：自动生成时间
    @Override
    @Transactional
    public void saveItemCatMP(ItemCat itemCat){
        // mybatis自动填充功能 自动填充时间
//        Date date=new Date();
//        itemCat.setStatus(true).setCreated(date).setUpdated(date);
        itemCat.setStatus(true);
        itemCatMapper.insert(itemCat);
    }

    @Override
    @Transactional  //事务控制
    public void deleteItemCat(ItemCat itemCat){
        Integer level=itemCat.getLevel();
        if (level==3){
            int id=itemCat.getId();
            itemCatMapper.deleteById(id);
        }else if(level==2){
            int id=itemCat.getId();
            QueryWrapper<ItemCat> queryWrapper=new QueryWrapper<>();
            queryWrapper.eq("parent_id",id);
            //先删除三级数据
            itemCatMapper.delete(queryWrapper);
            //再删除自己
            itemCatMapper.deleteById(id);
        }else if (level==1) {
            int id = itemCat.getId();
            QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id", id);
            //获取二级数据的id
            List idlist = itemCatMapper.selectObjs(queryWrapper);
            //判断是否有二级数据.如果有直接删除.如果没有直接删除一级
            if (idlist.size() > 0) {
                queryWrapper.clear();
                //删除parent_id为idlist的三级数据，即parent_id等于二级数据的id
                queryWrapper.in("parent_id", idlist);
                itemCatMapper.delete(queryWrapper);
                //将所有的1-2级的ID，封装到一个集合中
                idlist.add(id);
                //将所有1级2级全部删除  Sql where id in (xx,xx,xx,xx)
                itemCatMapper.deleteBatchIds(idlist);
            }else {
                itemCatMapper.deleteById(id);
            }
        }
    }
    @Override
    @Transactional
    public void updateItemCat(ItemCat itemCat){
        int id=itemCat.getId();
        UpdateWrapper<ItemCat> updateWrapper=new UpdateWrapper<>();
        //根据id修改商品分类的姓名
        updateWrapper.eq("id",id);
        Date date=new Date();
        //设置更新时间为当前时间
        itemCat.setUpdated(date);
        itemCatMapper.update(itemCat,updateWrapper);
    }
    @Override
    @Transactional
    public void updateStatusByIdMP(Integer id,Boolean status){
        UpdateWrapper<ItemCat> updateWrapper=new UpdateWrapper<>();
        updateWrapper.eq("id",id);
        ItemCat itemCat=new ItemCat();
        itemCat.setStatus(status);
        itemCatMapper.update(itemCat,updateWrapper);
    }
}

/**
 * 弊端: 由于多次循环遍历 查询数据库,导致数据库查询次数太多效率极低.
 * 思路:
 *      1.刚才的业务逻辑梳理
 *      2.如何优化?????   提高效率
 * 优化策略:
 *       降低用户查询数据库的次数.
 * @param level
 * @return
 */
    /*@Override
    public List<ItemCat> findItemCatList(Integer level) {
        //查询一级商品分类信息
        QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id",0);
        List<ItemCat> oneList = itemCatMapper.selectList(queryWrapper);
        //查询二级商品分类信息
        for(ItemCat oneItemCat: oneList){
            //1.为了复用条件构造器 将之前的数据清空
            queryWrapper.clear();
            //查询二级数据 parent_id = 一级ID
            queryWrapper.eq("parent_id",oneItemCat.getId());
            List<ItemCat> twoList = itemCatMapper.selectList(queryWrapper);
                    //遍历二级列表 查询三级数据,封装数据返回
            //将二级封装到一级
            oneItemCat.setChildren(twoList);
        }
        return oneList;
    }*/
/*
    多次循环效率太低，不用
//查询一级商品分类信息
        QueryWrapper<ItemCat> queryWrapper=new QueryWrapper<>();
        queryWrapper.eq("parent_id",0);
        List<ItemCat> onelist=itemCatMapper.selectList(queryWrapper);

        //查询二级商品分类信息
        for (ItemCat oneItemCat:onelist) {
            //1.为了复用条件构造器，将之前的数据清空
            queryWrapper.clear();
            Integer id=oneItemCat.getId();
            //查询二级数据 parent_id = 一级id
            queryWrapper.eq("parent_id",id);
            List<ItemCat> twolist=itemCatMapper.selectList(queryWrapper);
            oneItemCat.setChildren(twolist);
            //查询三级商品分类信息
            for (ItemCat twoItemCat:twolist) {
                //1.为了复用条件构造器，将之前的数据清空
                queryWrapper.clear();
                Integer id2=twoItemCat.getId();
                //查询三级数据 parent_id = 一级id
                queryWrapper.eq("parent_id",id2);
                List<ItemCat> threelist=itemCatMapper.selectList(queryWrapper);
                twoItemCat.setChildren(threelist);
            }
        }
 */